package org.dalmatian.common.tenant.builder;

import org.dalmatian.common.redis.config.properties.RedissonProperties;
import org.dalmatian.common.tenant.handle.TenantKeyPrefixHandler;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.TimeZone;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.codec.CompositeCodec;
import org.redisson.codec.TypedJsonJacksonCodec;
import org.redisson.config.Config;
import cn.hutool.core.util.ObjectUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class SolonTenantRedissonBuilder {

                private static final Logger log = LoggerFactory.getLogger(
                    SolonTenantRedissonBuilder.class);

                public static RedissonClient build(RedissonProperties redissonProperties) {

                                Config config = new Config();
                                JavaTimeModule javaTimeModule = new JavaTimeModule();
                                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                                javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(formatter));
                                javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(formatter));
                                ObjectMapper om = new ObjectMapper();
                                om.registerModule(javaTimeModule);
                                om.setTimeZone(TimeZone.getDefault());
                                om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
                                // 指定序列化输入的类型，类必须是非final修饰的。序列化时将对象全类名一起保存下来
                                om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
                                TypedJsonJacksonCodec jsonCodec = new TypedJsonJacksonCodec(Object.class, om);
                                // 组合序列化 key 使用 String 内容使用通用 json 格式
                                CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, jsonCodec, jsonCodec);
                                config.setThreads(redissonProperties.getThreads())
                                    .setNettyThreads(redissonProperties.getNettyThreads())
                                    // 缓存 Lua 脚本 减少网络传输(redisson 大部分的功能都是基于 Lua 脚本实现)
                                    .setUseScriptCache(true)
                                    .setCodec(codec);
                                // 判断是否启用 线程虚拟化
//                                if (SpringUtils.isVirtual()) {
//                                                config.setNettyExecutor(new VirtualThreadTaskExecutor("redisson-"));
//                                }
                                RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
                                if (ObjectUtil.isNotNull(singleServerConfig)) {
                                                // 使用单机模式
                                                config.useSingleServer()
                                                    //设置redis key前缀
                                                    .setNameMapper(new TenantKeyPrefixHandler(redissonProperties.getKeyPrefix()))
                                                    .setAddress(redissonProperties.getAddress())
//                                                    .setUsername(redissonProperties.getUsername())
                                                    .setPassword(redissonProperties.getPassword())
                                                    .setDatabase(redissonProperties.getDb())
                                                    .setTimeout(singleServerConfig.getTimeout())
                                                    .setClientName(singleServerConfig.getClientName())
                                                    .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
                                                    .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
                                                    .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
                                                    .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize());
                                }
                                // 集群配置方式 参考下方注释
                                RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
                                if (ObjectUtil.isNotNull(clusterServersConfig)) {
                                                config.useClusterServers()
                                                    //设置redis key前缀
                                                    .addNodeAddress(resolveServers(
                                                        redissonProperties.getAddress().split(",")))
//                                                    .setUsername(redissonProperties.getUsername())
                                                    .setPassword(redissonProperties.getPassword())
                                                    .setNameMapper(new TenantKeyPrefixHandler(redissonProperties.getKeyPrefix()))
                                                    .setTimeout(clusterServersConfig.getTimeout())
                                                    .setClientName(clusterServersConfig.getClientName())
                                                    .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
                                                    .setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
                                                    .setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
                                                    .setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
                                                    .setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
                                                    .setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
                                                    .setReadMode(clusterServersConfig.getReadMode())
                                                    .setSubscriptionMode(clusterServersConfig.getSubscriptionMode());
                                }

               return Redisson.create(config);
                }
                private static String[] resolveServers(String... servers) {
                                String[] uris = new String[servers.length];

                                for (int i = 0; i < servers.length; i++) {
                                                String sev = servers[i];

                                                if (sev.contains("://")) {
                                                                uris[i] = sev;
                                                } else {
                                                                uris[i] = "redis://" + sev;
                                                }
                                }

                                return uris;
                }
}
